import Vue from 'vue'
import Vuex from 'vuex'

import aiApi from '@/api/ai'

Vue.use(Vuex)

/**
 * AI聊天面板Vuex模块
 * 管理AI聊天面板的所有状态、SSE连接和业务逻辑
 * 与后端SSE API完全集成
 */
export default {
    state: {
        // 题库消息列表
        questionMessages: [],
        // 试卷消息列表
        paperMessages: [],

        // 界面状态
        // 是否显示 "AI正在输入状态"
        isTyping: false,
        // 是否正在发送消息
        isSending: false,
        // 是否显示聊天面板
        isPanelOpen: false,
        // 消息是否已初始化
        messagesInitialized: false,

        // 用户数据
        userInput: '',
        // 用户上传的文件信息
        uploadedFile: null,
        // 添加支持多文件上传
        uploadedFiles: [],
        // 当前激活的功能标签： （0:题库,1:试卷,2:考试,3:考生）
        activeTab: 0,

        // UI状态
        buttonPosition: {
            // 浮动按钮的位置
            left: window.innerWidth - 80,
            top: window.innerHeight / 2 - 30
        },
        

        // 连接状态
        streamController: null, // 改为存储AbortController
        // 连接状态(connecting, connected, disconnected, error)
        connectionStatus: 'disconnected',

        // 角色配置
        roleTabs: [
            {
                label: '题库',
                placeholder: '例如：推荐Python入门题库',
                defaultText: '',
                welcomeTitle: '智能题库助手',
                quickActions: [
                    '推荐Python入门题库',
                    '查找算法题库',
                    '推荐数据结构练习题',
                    '最新竞赛题库'
                ],
                route: '/question-bank',
                agentType:'question',
            },
            {
                label: '试卷',
                placeholder: '例如：帮我创建一张2025年语文期中试卷，考试时长120分钟',
                defaultText: '',
                welcomeTitle: '智能出卷助手',
                quickActions: [
                    '选择语文试卷',
                    '导出试卷',
                    '导出试卷题目',
                    '查看试卷详情',
                    '导入试卷',
                    '刷新页面',
                    '修改试卷名称为：xx试卷,时长 120 分钟',
                    '跳转题库页面',
                    '回到主页'
                ],
                route: '/paper',
                agentType:'paper',
            }
        ]
    },
    getters: {
        /**
         * 当前激活角色的欢迎消息
         * @param {Object} state - 模块状态
         * @returns {String} - 欢迎消息内容
         */
        currentWelcomeMessage: state => {
            const messages = [
                // ========== 独立定义的欢迎消息 ==========
                '我可以帮助您查找、推荐和管理各类题库资源。您可以问我关于题库分类、难度分级或特定主题的题库推荐。',
                '我可以帮助您快速创建试卷,你可以尝试对我说：创建一张2025年语文期中试卷，考试时长120分钟',
                '这里是考试管理面板，您可以：\n\n1. 创建和管理考试\n2. 安排考试时间和考场\n3. 分配监考老师\n4. 查看考试报名情况\n5. 分析考试统计数据',
                '这里是考生管理面板，您可以：\n\n1. 添加、修改和删除考生信息\n2. 查看报名情况和考试成绩\n3. 导出考生名单和成绩单\n4. 重置考生密码'
            ]
            return messages[state.activeTab] || '您好，请问有什么可以帮您？'
        },
        /**
         * 是否可以发送消息(输入不为空或已上传文件)
         * @param {Object} state - 模块状态
         * @returns {Boolean} - 是否可以发送
         */
        canSend: state => {
            // 是否可以发送消息
            return (state.userInput.trim().length > 0 || state.uploadedFile) && !state.isSending
        },

        /**
         * 当前激活角色的配置
         * @param {Object} state - 模块状态
         * @returns {Object} - 角色配置
         */
        currentRoleConfig: state => {
            return state.roleTabs[state.activeTab] || {}
        },

        /**
         * 获取当前应显示的消息列表
         * @param {Object} state - 模块状态
         * @returns {Array} - 当前消息列表
         */
        messages: (state, getters, rootState) => {
            // 使用安全的方式获取当前代理类型
            const currentAgentType = state.roleTabs[state.activeTab] && 
                state.roleTabs[state.activeTab].agentType || 'question';
            
            // 额外检查当前路由来进一步确认正确的消息类型
            // 因为有时activeTab可能未及时更新
            let isShowingPaper = currentAgentType === 'paper';
            
            // 如果有router数据，再进一步确认
            if (rootState && rootState.route && rootState.route.path) {
                const currentPath = rootState.route.path;
                // 如果路径明确包含paper，优先显示试卷消息
                if (currentPath.includes('/paper')) {
                    isShowingPaper = true;
                }
                // 如果路径明确包含question-bank，优先显示题库消息
                else if (currentPath.includes('/question-bank')) {
                    isShowingPaper = false;
                }
            }
            
            return isShowingPaper ? state.paperMessages : state.questionMessages;
        }
    },
    mutations: {
        /**
         * 设置消息列表
         * @param {Object} state - 模块状态
         * @param {Object} payload - 包含消息列表和rootState的对象
         */
        SET_MESSAGES(state, { messages, rootState }) {
            const currentAgentType = state.roleTabs[state.activeTab] && 
                state.roleTabs[state.activeTab].agentType || 'question';
            
            if (currentAgentType === 'paper') {
                state.paperMessages = messages;
                // 保存到本地存储
                const userId = rootState && rootState.user && rootState.user.userInfo && rootState.user.userInfo.userId;
                saveUserMessages(messages, 'paper', userId);
            } else {
                state.questionMessages = messages;
                // 保存到本地存储
                const userId = rootState && rootState.user && rootState.user.userInfo && rootState.user.userInfo.userId;
                saveUserMessages(messages, 'question', userId);
            }
        },

        /**
         * 清空消息列表
         * @param state - Vuex状态对象
         */
        CLEAR_MESSAGES(state, { rootState }) {
            const currentAgentType = state.roleTabs[state.activeTab] && 
                state.roleTabs[state.activeTab].agentType || 'question';
            const userId = rootState && rootState.user && rootState.user.userInfo && rootState.user.userInfo.userId;
            
    
            
            if (!userId) {
                console.warn('缺少用户ID，无法清空消息');
                return;
            }
            
            if (currentAgentType === 'paper') {
                // 清空试卷消息
                state.paperMessages = [];
                // 清空本地存储
                saveUserMessages([], 'paper', userId);
               
            } else {
                // 清空题库消息
                state.questionMessages = [];
                // 清空本地存储
                saveUserMessages([], 'question', userId);
              
            }
            
            // 重置消息初始化状态，以便再次添加欢迎消息
            state.messagesInitialized = false;
        },

        /**
         * 添加新消息
         * @param {Object} state - 模块状态
         * @param {Object} payload - 消息内容
         */
        ADD_MESSAGES(state, {type, content, streaming = false, rootState}) {
            const currentAgentType = state.roleTabs[state.activeTab] && 
                state.roleTabs[state.activeTab].agentType || 'question';
            const message = {
                type,
                content,
                time: new Date().toISOString(),
                streaming,
            };
            
            // 根据当前类型选择消息列表
            let messages;
            if (currentAgentType === 'paper') {
                messages = [...state.paperMessages];
            } else {
                messages = [...state.questionMessages];
            }
            
            // AI流式合并
            if (type === 'ai-message' && streaming) {
                const lastIndex = messages.length - 1;
                const lastMessage = messages[lastIndex];
                if (lastMessage && lastMessage.type === 'ai-message' && lastMessage.streaming) {
                    lastMessage.content += content;
                    
                    if (currentAgentType === 'paper') {
                        state.paperMessages = messages;
                    } else {
                        state.questionMessages = messages;
                    }
                    
                    // 获取用户ID
                    const userId = rootState && rootState.user && rootState.user.userInfo && rootState.user.userInfo.userId;
                    
                    // 保存到本地存储
                    saveUserMessages(messages, currentAgentType, userId);
                    return;
                }
            }
            
            messages.push(message);
            
            if (currentAgentType === 'paper') {
                state.paperMessages = messages;
            } else {
                state.questionMessages = messages;
            }
            
            // 获取用户ID
            const userId = rootState && rootState.user && rootState.user.userInfo && rootState.user.userInfo.userId;
            
            // 保存到本地存储
            saveUserMessages(messages, currentAgentType, userId);
        },

        /**
         * 更新用户输入
         * @param {Object} state - Vuex状态对象
         * @param {String} input - 用户输入
         */
        SET_USER_INPUT(state, input) {
            state.userInput = input
        },

        /**
         * 更新消息流状态
         * @param {Object} state - Vuex状态对象
         * @param {Boolean} isTyping - 是否完成流式消息
         */
        SET_TYPING(state, isTyping) {
            state.isTyping = isTyping

            // 如果结束输入，将最后一条流式消息标记为完成
            if (!isTyping) {
                const messageType = state.roleTabs[state.activeTab] && 
                    state.roleTabs[state.activeTab].agentType === 'paper';
                const messages = messageType ? state.paperMessages : state.questionMessages;
                const lastMessage = messages[messages.length - 1];
                if (lastMessage && lastMessage.streaming) {
                    lastMessage.streaming = false;
                }
            }
        },

        /**
         * 设置发送状态
         * @param {Object} state - Vuex状态对象
         * @param {Boolean} isSending - 是否正在发送
         */
        SET_SENDING(state, isSending) {
            state.isSending = isSending
        },

        /**
         * 设置面板展开状态
         * @param {Object} state - Vuex状态对象
         * @param {Boolean} isOpen - 是否展开
         */
        SET_PANEL_OPEN(state, isOpen) {
            state.isPanelOpen = isOpen
        },

        /**
         * 设置上传的文件
         * @param {Object} state - Vuex状态对象
         * @param {File} file - 上传的文件
         */
        SET_UPLOADED_FILE(state ,file) {
            state.uploadedFile = file
        },

        /**
         * 添加上传的文件到文件列表
         * @param {Object} state - Vuex状态对象
         * @param {File} file - 上传的文件
         */
        ADD_UPLOADED_FILE(state, file) {
            state.uploadedFiles.push(file)
            // 同时更新单文件状态保持兼容性
            state.uploadedFile = file
        },

        /**
         * 从文件列表中移除文件
         * @param {Object} state - Vuex状态对象
         * @param {Number} index - 文件索引
         */
        REMOVE_UPLOADED_FILE(state, index) {
            state.uploadedFiles.splice(index, 1)
            // 更新单文件状态保持兼容性
            state.uploadedFile = state.uploadedFiles.length > 0 ? state.uploadedFiles[0] : null
        },

        /**
         * 清空所有上传的文件
         * @param {Object} state - Vuex状态对象
         */
        CLEAR_UPLOADED_FILES(state) {
            state.uploadedFiles = []
            state.uploadedFile = null
        },

        /**
         * 设置当前激活的标签页
         * @param {Object} state - Vuex状态对象
         * @param {Number} tabIndex - 标签页索引
         */
        SET_ACTIVE_TAB(state, tabIndex) {
            state.activeTab = tabIndex;
            // 加载对应标签页的消息列表不需要额外操作，由 getters.messages 负责
        },

        /**
         * 设置按钮的位置
         * @param {Object} state - Vuex状态对象
         * @param {String} position - 按钮的位置
         */
        SET_BUTTON_POSITION(state, position) {
            state.buttonPosition = position
        },
        /**
         * 设置连接状态
         * @param {Object} state - Vuex状态对象
         * @param {String} status - 连接状态
         */
        SET_CONNECTION_STATUS(state, { status, rootState }) {
            state.connectionStatus = status;
            // 只在连接错误时清除所有消息
            if (status === 'error') {
                const currentAgentType = state.roleTabs[state.activeTab] && 
                    state.roleTabs[state.activeTab].agentType || 'question';
                const userId = rootState && rootState.user && rootState.user.userInfo && rootState.user.userInfo.userId;
                
                if (currentAgentType === 'paper') {
                    state.paperMessages = [];
                    saveUserMessages([], 'paper', userId);
                } else {
                    state.questionMessages = [];
                    saveUserMessages([], 'question', userId);
                }
            }
        },

         /**
         * 设置流式控制器
         * @param {Object} state - Vuex状态对象
         * @param {AbortController} controller - 流式控制器实例
         */
         SET_STREAM_CONTROLLER(state, controller) {
            // 取消现有请求
            if (state.streamController) {
                state.streamController.abort()
            }
            state.streamController = controller
        },

        /**
         * 设置消息初始化状态
         * @param {Object} state - Vuex状态对象
         * @param {Boolean} initialized - 是否已初始化
         */
        SET_MESSAGES_INITIALIZED(state, initialized) {
            state.messagesInitialized = initialized;
        }
    },
    actions: {    
       /**
         * 初始化流式连接（修改为Fetch API实现）
         * @param {Object} context - Vuex上下文
         * @param {Object} params - 连接参数
         */
       async initSSEConnection({ commit, state, dispatch, rootState }, params) {
            try {
                // 验证必需参数
                const requiredParams = ['prompt', 'agentType']
                const missingParams = requiredParams.filter(p => !params[p])
                
                if (missingParams.length > 0) {
                    throw new Error(`缺少必需参数: ${missingParams.join(', ')}`)
                }

                // 关闭现有连接
                await dispatch('closeConnection')
                
                // 设置连接状态
                commit('SET_CONNECTION_STATUS', { status: 'connecting', rootState })

                // 创建新的AbortController
                const controller = new AbortController()
                commit('SET_STREAM_CONTROLLER', controller)

                // 启动流式连接
                await aiApi.startChatStream(
                    params,
                    {
                        onOpen: () => commit('SET_CONNECTION_STATUS', { status: 'connected', rootState }),
                        onMessage: (data) => {
                            try {
                                if (data === '[complete]') {
                                    commit('SET_TYPING', false)
                                    commit('SET_CONNECTION_STATUS', { status: 'disconnected', rootState })
                                    return
                                }
                                
                                const response = typeof data === 'string' ? JSON.parse(data) : data
                                commit('ADD_MESSAGES', {
                                    type: 'ai-message',
                                    content: response.data || response,
                                    streaming: true,
                                    rootState
                                })
                            } catch (error) {
                                console.error("消息解析错误:", error)
                                dispatch("handleStreamError", error.message)
                            }
                        },
                        onError: (error) => {
                            console.error('流式连接错误:', error)
                            dispatch('handleStreamError', error.message)
                        },
                        onComplete: () => {
                            commit('SET_TYPING', false)
                            commit('SET_CONNECTION_STATUS', { status: 'disconnected', rootState })
                        }
                    },
                    controller
                )

            } catch (error) {
                console.error('流式初始化失败:', error)
                dispatch('handleStreamError', error.message)
                throw error
            }
         },
        /**
         * 处理SSE错误
         * @param {Object} context - Vuex上下文
         * @param {String} errorMessage - 错误消息
         */
        handleStreamError({ commit, rootState }, errorMessage) {
            // 重置所有相关状态
            commit('SET_STREAM_CONTROLLER', null)
            commit('SET_TYPING', false)
            commit('SET_SENDING', false)
            commit('SET_CONNECTION_STATUS', { status: 'error', rootState })

            // 添加错误消息到聊天记录
            commit('ADD_MESSAGES', {
                type: 'error-message',
                content: `错误: ${errorMessage || '未知错误'}`,
                rootState
            })
        },

       /**
         * 发送消息（优化版打字机效果）
         * @param {Object} param0 - 上下文对象
         * @param {Object} params - 消息参数，匹配后端AiChatModelVO
         * @param {string} params.prompt - 用户输入的消息内容
         * @param {string} params.agentType - 代理类型
         * @param {boolean} params.hasFile - 是否有文件
         * @param {File} [params.file] - 文件对象
         */
        async sendMessage({ commit, state, dispatch, getters, rootState }, params) {
            try {
                commit('SET_SENDING', true);
                
                const { 
                    prompt,
                    agentType = (state.roleTabs[state.activeTab] && 
                        state.roleTabs[state.activeTab].agentType) || 'question',
                    userId,
                    sessionId,
                    hasFile,
                    file
                } = params;
                
                const currentInput = prompt || state.userInput.trim();

                if (!currentInput && !hasFile) {
                    throw new Error('输入内容不能为空');
                }

                // 添加用户消息
                commit('ADD_MESSAGES', {
                    type: 'user-message',
                    content: currentInput,
                    rootState
                });

                if (hasFile && file) {
                    commit('ADD_MESSAGES', {
                        type: 'file-message',
                        content: `已上传文件：${file.name}`,
                        rootState
                    });
                }

                // 添加AI消息占位
                commit('ADD_MESSAGES', {
                    type: 'ai-message',
                    content: '',
                    streaming: true,
                    rootState
                });

                // 启动流式连接
                commit('SET_TYPING', true);
                commit('SET_USER_INPUT', '');

                const currentRole = state.roleTabs[state.activeTab] || {};
                const finalAgentType = agentType || (currentRole && currentRole.agentType) || 'question';

                // 构建请求参数，匹配后端AiChatModelVO
                const requestParams = {
                    prompt: currentInput,
                    agentType: finalAgentType,
                    userId: userId || localStorage.getItem('userId') || '',
                    sessionId: sessionId || localStorage.getItem('sessionId') || `session_${Date.now()}`,
                    hasFile: hasFile
                };
                
                // 如果有文件，添加文件对象，API层会处理转Base64
                if (hasFile && file) {
                    requestParams.file = file;
                }

                // 获取当前消息列表
                const messages = getters.messages;

                await aiApi.startTypingStream(
                    requestParams,
                    {
                        onMessage: (content, isDone) => {
                            const lastIndex = messages.length - 1;
                            
                            if (lastIndex >= 0 && messages[lastIndex] && 
                                messages[lastIndex].type === 'ai-message') {
                                // 先创建更新后的消息数组
                                const updatedMessages = [
                                    ...messages.slice(0, lastIndex),
                                    {
                                        ...messages[lastIndex],
                                        content: content,
                                        streaming: !isDone
                                    }
                                ];
                                
                                // 更新状态
                                commit('SET_MESSAGES', { messages: updatedMessages, rootState });
                                
                                // 如果消息结束但内容为空，移除该消息
                                if (isDone && !content.trim()) {
                                    commit('SET_MESSAGES', { messages: updatedMessages.slice(0, lastIndex), rootState });
                                }
                            }          
                        },
                        onError: (error) => {
                            dispatch('handleStreamError', error.message);
                        },
                        onComplete: () => {
                            commit('SET_TYPING', false);
                            // 发送完成后清空文件
                            commit('CLEAR_UPLOADED_FILES');
                        }
                    }
                );

            } catch (error) {
                console.error('消息发送失败:', error);
                
                // 获取当前消息列表
                const currentAgentType = state.roleTabs[state.activeTab] && 
                    state.roleTabs[state.activeTab].agentType === 'paper';
                const messages = currentAgentType ? state.paperMessages : state.questionMessages;
                
                // 移除AI消息占位
                if (messages.length > 0 && messages[messages.length - 1] && 
                    messages[messages.length - 1].type === 'ai-message' && 
                    messages[messages.length - 1].streaming) {
                    commit('SET_MESSAGES', { messages: messages.slice(0, -1), rootState });
                }

                commit('ADD_MESSAGES', {
                    type: 'error-message',
                    content: `发送失败: ${error.message}`,
                    rootState
                });

            } finally {
                commit('SET_SENDING', false);
                commit('SET_TYPING', false);
            }
        },
        /**
         * 关闭流式连接（修改为AbortController实现）
         * @param {Object} context - Vuex上下文
         */
        async closeConnection({ commit, state, rootState }) {
            try {
                if (state.streamController) {
                    state.streamController.abort()
                }
            } catch (error) {
                console.error('关闭连接时出错:', error)
            } finally {
                commit('SET_STREAM_CONTROLLER', null)
                commit('SET_TYPING', false)
                commit('SET_SENDING', false)
                commit('SET_CONNECTION_STATUS', { status: 'disconnected', rootState })
            }
        },


        /**
         * 重新生成最后一条AI消息
         * @param {Object} context - Vuex上下文
         */
        async regenerateLastMessage({ state, dispatch, getters, rootState }) {
            // 获取当前消息列表
            const messages = getters.messages;
            
            // 获取最后一条用户消息
            const lastUserMessage = [...messages]
                .reverse()
                .find(m => m.type === 'user-message');

            if (lastUserMessage) {
                // 找出最后一条用户消息之后的AI消息
                const lastUserIndex = messages.findIndex(m => m === lastUserMessage);
                const aiMessageIndex = messages.findIndex(
                    (m, index) => index > lastUserIndex && m.type === 'ai-message'
                );
                
                if (aiMessageIndex !== -1) {
                    // 创建一个新的消息数组，移除AI消息
                    const newMessages = [...messages];
                    newMessages.splice(aiMessageIndex, 1);
                    // 更新消息列表
                    const currentAgentType = state.roleTabs[state.activeTab] && 
                        state.roleTabs[state.activeTab].agentType;
                    const userId = rootState && rootState.user && rootState.user.userInfo && rootState.user.userInfo.userId;
                    saveUserMessages(newMessages, currentAgentType, userId);
                    if (currentAgentType === 'paper') {
                        state.paperMessages = newMessages;
                    } else {
                        state.questionMessages = newMessages;
                    }
                }
                
                // 重新发送请求
                dispatch('setUserInput', lastUserMessage.content);
                await dispatch('sendMessage');
            }
        },

        /**
         * 初始化消息 - 应在用户信息加载后调用
         * @param {Object} context - Vuex上下文
         */
        initializeMessages({ state, dispatch, rootState }) {
            // 如果已经初始化过，不重复初始化
            if (state.messagesInitialized) return;
            
            // 确保有用户ID
            const userId = rootState && rootState.user && rootState.user.userInfo && rootState.user.userInfo.userId;
            if (!userId) {
                console.warn('尝试初始化消息但用户ID不可用');
                return;
            }
            
            // 初始化当前标签的消息
            dispatch('initializeTabMessages', state.activeTab);
            
            // 标记为已初始化
            state.messagesInitialized = true;
        },

        /**
         * 初始化标签消息
         * @param {Object} context - Vuex上下文
         * @param {Number} tabIndex - 标签索引
         */
        initializeTabMessages({ commit, state, dispatch, rootState }, tabIndex) {
            const currentAgentType = state.roleTabs[tabIndex] && 
                state.roleTabs[tabIndex].agentType || 'question';
            const userId = rootState && rootState.user && rootState.user.userInfo && rootState.user.userInfo.userId;
            
            // 如果没有用户ID，不加载消息
            if (!userId) {
                console.warn('尝试初始化标签消息但用户ID不可用');
                return;
            }
            
            const messages = loadUserMessages(currentAgentType, userId);
           
            
            // 更新状态 - 确保更新正确的消息列表
            if (currentAgentType === 'paper') {
                state.paperMessages = messages;
             
            } else {
                state.questionMessages = messages;
               
            }
            
            // 只有当没有任何消息时，才添加欢迎消息
            if (!messages || messages.length === 0) {
                // 强制添加欢迎消息而不是通过dispatch
                const welcomeContent = state.roleTabs[tabIndex] && tabIndex === 0 
                    ? '我可以帮助您查找、推荐和管理各类题库资源。您可以问我关于题库分类、难度分级或特定主题的题库推荐。'
                    : '我可以帮助您快速创建试卷,你可以尝试对我说：创建一张2025年语文期中试卷，考试时长120分钟';
                
                const welcomeMsg = {
                    type: 'ai-message',
                    content: welcomeContent,
                    isWelcome: true,
                    time: new Date().toISOString()
                };
                
                if (currentAgentType === 'paper') {
                    state.paperMessages = [welcomeMsg];
                    saveUserMessages([welcomeMsg], currentAgentType, userId);
                  
                } else {
                    state.questionMessages = [welcomeMsg];
                    saveUserMessages([welcomeMsg], currentAgentType, userId);
                   
                }
            }
            
            // 标记消息已初始化
            commit('SET_MESSAGES_INITIALIZED', true);
            
            return messages;
        },

        /**
         * 切换功能标签
         * @param {Object} context - Vuex上下文
         * @param {Number} tabIndex - 标签索引
         */
        async switchTab({commit, state, dispatch, rootState}, tabIndex) {
           
            
            if (tabIndex === state.activeTab) return;
            if (state.connectionStatus === 'connected' || state.isTyping) {
                await dispatch('closeConnection');
                
                // 更新最后一条流式消息状态
                const currentAgentType = state.roleTabs[state.activeTab] && 
                    state.roleTabs[state.activeTab].agentType === 'paper';
                const messages = currentAgentType ? state.paperMessages : state.questionMessages;
                const lastMessage = messages[messages.length - 1];
                if (lastMessage && lastMessage.streaming) {
                    lastMessage.streaming = false;
                    commit('SET_MESSAGES', { messages, rootState });
                }
            }
            
            // 更新当前标签
            commit('SET_ACTIVE_TAB', tabIndex);
            
            // 确保有用户ID
            const userId = rootState && rootState.user && rootState.user.userInfo && rootState.user.userInfo.userId;
           
            
            if (!userId) {
                console.warn('切换标签但用户ID不可用');
                return;
            }
            
            // 加载新tab的消息
            const currentAgentType = state.roleTabs[tabIndex] && 
                state.roleTabs[tabIndex].agentType || 'question';
         
            
            const messages = loadUserMessages(currentAgentType, userId);
       
            
            if (currentAgentType === 'paper') {
                state.paperMessages = messages;
            } else {
                state.questionMessages = messages;
            }
            
            // 如果没有消息，添加欢迎消息
            if (messages.length === 0) {
                await dispatch('addWelcomeMessage');
            }
            
            commit('CLEAR_UPLOADED_FILES');
            return {
                route: state.roleTabs[tabIndex] && state.roleTabs[tabIndex].route,
                defaultText: (state.roleTabs[tabIndex] && state.roleTabs[tabIndex].defaultText) || ''
            };
        },

        /**
         * 添加欢迎消息
         * @param {Object} context - Vuex上下文
         * @param {Boolean} force - 是否强制添加欢迎消息，无论是否已有消息
         */
        addWelcomeMessage({commit, state, getters, rootState}, force = false) {
            const currentAgentType = state.roleTabs[state.activeTab] && 
                state.roleTabs[state.activeTab].agentType || 'question';
            const welcomeContent = getters.currentWelcomeMessage;
            const userId = rootState && rootState.user && rootState.user.userInfo && rootState.user.userInfo.userId;
            
        
            
            if (!userId) {
                console.warn('添加欢迎消息失败：用户ID不可用');
                return;
            }
            
            // 获取当前消息列表
            const messages = currentAgentType === 'paper' 
                ? state.paperMessages : state.questionMessages;
            
            // 检查是否已经有欢迎消息
            const hasWelcome = messages.some(m => 
                m.type === 'ai-message' && m.isWelcome
            );

            // 检查localStorage中是否已经有消息
            const storedMessages = loadUserMessages(currentAgentType, userId);
            const hasStoredMessages = storedMessages && storedMessages.length > 0;
            
            // 只有当消息列表中没有欢迎消息且localStorage中没有消息时，或强制添加时，才添加欢迎消息
            if (force || (!hasWelcome && !hasStoredMessages)) {
                const welcomeMsg = {
                    type: 'ai-message',
                    content: welcomeContent,
                    isWelcome: true,
                    time: new Date().toISOString()
                };
                
              
                
                // 添加欢迎消息
                const updatedMessages = [...messages, welcomeMsg];
                
                // 保存到存储和状态
                if (currentAgentType === 'paper') {
                    state.paperMessages = updatedMessages;
                } else {
                    state.questionMessages = updatedMessages;
                }
                saveUserMessages(updatedMessages, currentAgentType, userId);
                
            } else {
                console.log('已存在欢迎消息，不重复添加');
            }
        },

        /**
         * 保存按钮位置到本地存储
         * @param {Object} context - Vuex上下文对象 param0 
         */
        saveButtonPosition({ commit }, position) {
            commit('SET_BUTTON_POSITION', position);
            // 保存到本地存储
            localStorage.setItem('aiButtonPosition', JSON.stringify(position));
          },


        /**
         * 从本地存储加载按钮位置
         * @param {Object} context - Vuex上下文对象
         */
        loadButtonPosition({ commit }) {
            const savedPosition = localStorage.getItem('aiButtonPosition');
            if (savedPosition) {
                commit('SET_BUTTON_POSITION', JSON.parse(savedPosition));
            }
        },

        /**
         * 设置用户输入
         * @param {Object} context - Vuex上下文对象
         * @param {String} input - 用户输入
        */
        setUserInput({ commit }, input) {
            commit('SET_USER_INPUT', input)
        },

        /**
         * 添加一条消息
         * @param {Object} context - Vuex上下文
         * @param {Object} payload - 消息内容 
         * @param {String} payload.content - 消息内容
         * @param {String} payload.sender - 发送者(ai/user)
         * @param {String} payload.type - 消息类型(text/file等)
         */
        addMessage({ commit }, { content, sender, type }) {
            // 将参数转换为ADD_MESSAGES需要的格式
            const messageType = sender === 'ai' ? 'ai-message' : 'user-message';
            
            commit('ADD_MESSAGES', {
                type: messageType,
                content: content,
                time: new Date().toISOString()
            });
        },

        /**
         * 设置上传的文件
         * @param {Object} context - Vuex上下文对象
         * @param {File} file - 文件对象
         */
        setUploadedFile({ commit }, file) {
            commit('SET_UPLOADED_FILE', file)
        },

        /**
         * 添加上传的文件
         * @param {Object} context - Vuex上下文对象
         * @param {File} file - 文件对象
         */
        addUploadedFile({ commit }, file) {
            commit('ADD_UPLOADED_FILE', file)
        },

        /**
         * 移除上传的文件
         * @param {Object} context - Vuex上下文对象
         * @param {Number} index - 文件索引
         */
        removeUploadedFile({ commit }, index) {
            commit('REMOVE_UPLOADED_FILE', index)
        },

        /**
         * 清除所有本地存储的消息
         * @param {Object} context - Vuex上下文
         */
        clearAllStoredMessages({rootState}) {
            const userId = rootState && rootState.user && rootState.user.userInfo && rootState.user.userInfo.userId;
            saveUserMessages([], 'question', userId);
            saveUserMessages([], 'paper', userId);
        },
    }
}

// 获取当前用户的本地存储key
function getUserMessageKey(type, userId) {
  // 必须有有效的userId，不再使用guest作为默认值
  if (!userId) {
    console.warn('尝试获取消息key但userId为空');
    return null;
  }
  return `ai_session_messages_${userId}_${type}`;
}

// 加载用户消息
function loadUserMessages(type, userId) {
  // 如果没有有效的userId，返回空数组
  if (!userId) {
    console.warn('尝试加载消息但userId为空');
    return [];
  }
  
  const key = getUserMessageKey(type, userId);
  if (!key) return [];
  
  const raw = localStorage.getItem(key);
  return raw ? JSON.parse(raw) : [];
}

// 保存用户消息
function saveUserMessages(messages, type, userId) {
  // 如果没有有效的userId，不执行保存
  if (!userId) {
    console.warn('尝试保存消息但userId为空');
    return;
  }
  
  const key = getUserMessageKey(type, userId);
  if (!key) return;
  
  localStorage.setItem(key, JSON.stringify(messages));
}               
                

